package com.example.lib_common.exception

import android.annotation.SuppressLint
import android.content.Context
import android.content.pm.PackageManager
import android.os.Build
import android.os.Environment
import android.os.Looper
import android.os.Process
import android.util.Log
import android.widget.Toast
import java.io.File
import java.io.FileNotFoundException
import java.io.FileOutputStream
import java.io.IOException
import java.io.PrintWriter
import java.io.StringWriter
import java.io.Writer
import java.text.SimpleDateFormat
import java.util.Date
import kotlin.system.exitProcess

class CrashHandler
/**
 * 保证只有一个CrashHandler实例
 */
private constructor() : Thread.UncaughtExceptionHandler {
    private var mDefaultHandler: Thread.UncaughtExceptionHandler? =
        null // 系统默认的UncaughtException处理类
    private var mContext: Context? = null // 程序的Context对象
    private val info: MutableMap<String?, String?> = HashMap<String?, String?>() // 用来存储设备信息和异常信息

    @SuppressLint("SimpleDateFormat")
    private val format = SimpleDateFormat("yyyy-MM-dd HH:mm:ss") // 用于格式化日期,作为日志文件名的一部分

    /**
     * 初始化
     *
     * @param context
     */
    fun init(context: Context) {
        mContext = context
        mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler() // 获取系统默认的UncaughtException处理器
        Thread.setDefaultUncaughtExceptionHandler(this) // 设置该CrashHandler为程序的默认处理器
    }

    /**
     * 当UncaughtException发生时会转入该重写的方法来处理
     */
    override fun uncaughtException(thread: Thread, ex: Throwable) {
        if (!handleException(ex) && mDefaultHandler != null) {
// 如果自定义的没有处理则让系统默认的异常处理器来处理
            mDefaultHandler!!.uncaughtException(thread, ex)
        } else {
            try {
                Thread.sleep(2000) // 如果处理了，让程序继续运行3秒再退出，保证文件保存并上传到服务器
            } catch (e: InterruptedException) {
                e.printStackTrace()
            } // // 退出程序

            // App.exit(mContext);
            Process.killProcess(Process.myPid())
            exitProcess(1)
        }
    }

    /**
     * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成.
     *
     * @param ex 异常信息
     * @return true 如果处理了该异常信息;否则返回false.
     */
    fun handleException(ex: Throwable?): Boolean {
        if (ex == null) return false
        object : Thread() {
            override fun run() {
                Looper.prepare()
                Toast.makeText(
                    mContext,
                    "sorry!!!app出问题了，正在把日志保存到sdcard crash目录下",
                    Toast.LENGTH_SHORT
                ).show()
                Looper.loop()
            }
        }.start()
        // 收集设备参数信息
        collectDeviceInfo(mContext!!)
        // 保存日志文件
        saveCrashInfo2File(ex)

        Log.w(TAG, ex.message!!)
        return true
    }

    /**
     * 收集设备参数信息
     *
     * @param context
     */
    fun collectDeviceInfo(context: Context) {
        try {
            val pm = context.packageManager // 获得包管理器
            val pi = pm.getPackageInfo(
                context.packageName,
                PackageManager.GET_ACTIVITIES
            ) // 得到该应用的信息，即主Activity
            if (pi != null) {
                val versionName: String = (if (pi.versionName == null) "null" else pi.versionName)!!
                val versionCode = pi.versionCode.toString() + ""
                info.put("versionName", versionName)
                info.put("versionCode", versionCode)
            }
        } catch (e: PackageManager.NameNotFoundException) {
            e.printStackTrace()
        }
        val fields = Build::class.java.declaredFields // 反射机制
        for (field in fields) {
            try {
                field.isAccessible = true
                info.put(field.getName(), field.get("")?.toString())
                Log.d(TAG, field.getName() + ":" + field.get(""))
            } catch (e: IllegalArgumentException) {
                e.printStackTrace()
            } catch (e: IllegalAccessException) {
                e.printStackTrace()
            }
        }
    }

    private fun saveCrashInfo2File(ex: Throwable): String? {
        val sb = StringBuffer()
        for (entry in info.entries) {
            val key = entry.key
            val value = entry.value
            sb.append("$key=$value\r\n")
        }
        val writer: Writer = StringWriter()
        val pw = PrintWriter(writer)
        ex.printStackTrace(pw)
        var cause = ex.cause
        // 循环着把所有的异常信息写入writer中
        while (cause != null) {
            cause.printStackTrace(pw)
            cause = cause.cause
        }
        pw.close() // 记得关闭
        val result = writer.toString()
        sb.append(result)
        // 保存文件
//long timetamp = System.currentTimeMillis();
        val time = format.format(Date())
        val fileName = "crash-$time.log"
        if (Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED) {
            try {
                val dir = File(
                    (mContext!!.externalCacheDir.toString() + File.separator
                            + "crash")
                )
                Log.i("CrashHandler", dir.toString())
                if (!dir.exists()) dir.mkdir()
                val fos = FileOutputStream(File(dir, fileName + System.currentTimeMillis()))
                fos.write(sb.toString().toByteArray())
                fos.close()
                return fileName
            } catch (e: FileNotFoundException) {
                Log.i("CrashHandler", "FileNotFoundException")
                e.printStackTrace()
            } catch (e: IOException) {
                e.printStackTrace()
            }
        }
        return null
    }

    companion object {
        private const val TAG = "CrashHandler"

        /**
         * 获取CrashHandler实例 ,单例模式
         */
        val instance: CrashHandler = CrashHandler() // CrashHandler实例
    }
}
